package nancal.mp.mvc.ops


import nancal.mp.db.mongo.GitServerTypeEnum
import nancal.mp.db.mongo.mor
import nancal.mp.model.git.GitBranchCommitModel
import nancal.mp.service.git.GitApiService
import nancal.mp.service.git.impl.GitEaService
import nbcp.base.annotation.DefaultNumberValue
import nbcp.base.annotation.Require
import nbcp.base.comm.ListResult
import nbcp.base.extend.AsString
import nbcp.base.extend.HasValue
import nbcp.base.extend.must
import nbcp.base.utils.SpringUtil
import nbcp.mvc.sys.setDownloadFileName
import nbcp.myoql.db.mongo.query
import nbcp.myoql.db.mongo.queryById
import org.springframework.web.bind.annotation.GetMapping
import org.springframework.web.bind.annotation.PostMapping
import org.springframework.web.bind.annotation.RequestMapping
import org.springframework.web.bind.annotation.RestController
import java.io.File
import javax.servlet.http.HttpServletResponse

@RequestMapping("/ops/git")
@RestController
class OpsGitController {

//    @PostMapping("/save-file")
//    fun saveFile(
//        gitServerId: String,
//        gitServerCode: String,
//        owner: String,
//        repo: String,
//        branch: String,
//        fileName: String,
//        committerName: String,
//        message: String,
//        @RequestBody content: String
//    ): JsonResult {
//        val gitServer = mor.dev.gitServer.query()
//            .apply {
//                if (gitServerId.HasValue) {
//                    this.where { it.id mongoEquals gitServerId }
//                }
//
//                if (gitServerCode.HasValue) {
//                    this.where { it.code mongoEquals gitServerCode }
//                }
//            }.toEntity();
//        if (gitServer == null) {
//            return JsonResult.error("找不到git服务器")
//        }
//
//        val gitApiSercie = GitApiService.getInstance(gitServer.gitApiServerType);
//        val existsResult = gitApiSercie.existsFile(gitServer,owner,repo,branch,fileName)
//        if (   existsResult.data == false ) {
//            return gitApiSercie.createFile(gitServer, owner, repo, branch, fileName, committerName, message, content);
//        } else {
//            return gitEaSgitApiSercie .updateFile(gitServer, owner, repo, branch, fileName, committerName, message, content, sha)
//        }
//    }

    /**
     * 如果找不到，返回空
     */
//    @GetMapping("/get-file")
//    fun getFile(
//        gitServerId: String,
//        gitServerCode: String,
//        owner: String,
//        repo: String,
//        branch: String,
//        fileName: String,
//        response: HttpServletResponse
//    ): ApiResult<String>? {
//        val gitServer = mor.dev.gitServer.query()
//            .apply {
//                if (gitServerId.HasValue) {
//                    this.where { it.id mongoEquals gitServerId }
//                }
//
//                if (gitServerCode.HasValue) {
//                    this.where { it.code mongoEquals gitServerCode }
//                }
//            }.toEntity();
//        if (gitServer == null) {
//            return ApiResult.error("找不到git服务器")
//        }
//
//        var ret = gitEaService.getRawFile(gitServer, owner, repo, branch, fileName)
//        if (ret.msg.HasValue) {
//            return ApiResult.error(ret.msg)
//        }
//
//        if (ret.data == null) {
//            return ApiResult.error("error")
//        }
//
//        if (ret.data!!.content.HasValue) {
//            return ApiResult.of(ret.data!!.content)
//        }
//
//        response.outputStream.write(ret.data!!.byteArray)
//        response.setDownloadFileName(fileName)
//        return null
//    }


    /**
     * 默认克隆 gitea
     */
    @GetMapping("/clone")
    fun cloneFile(
        gitServerCode: String,
        gitServerId: String,
        owner: String,
        repo: String,
        branch: String,
        response: HttpServletResponse
    ) {
        if (gitServerId.isEmpty() && gitServerCode.isEmpty()) {
            throw RuntimeException("gitServerId 或 gitServerCode 不能都为空！")
        }


        val gitServer = mor.dev.gitServer.query()
            .apply {
                if (gitServerId.HasValue) {
                    this.where { it.id mongoEquals gitServerId }
                }
                if (gitServerCode.HasValue) {
                    this.where { it.code mongoEquals gitServerCode }
                }
            }.toEntity();

        if (gitServer == null) {
            throw RuntimeException("找不到git服务器")
        }

        if (gitServer.gitServerType == GitServerTypeEnum.Gitlab) {
            throw RuntimeException("GitLab 目前不支持 clone!")
        }

        var ret = SpringUtil.getBean<GitEaService>()
            .cloneZipFile(gitServer.host, gitServer.accessToken, owner, repo, branch)
        if (ret.data == null) {
            throw RuntimeException("error")
        }

        response.setDownloadFileName("${repo}.zip");

        File(ret.data!!).inputStream().transferTo(response.outputStream)
    }


    @PostMapping("/get-branches")
    fun getBranches(
        @Require gitId: String,
        @DefaultNumberValue(36) take: Int,
    ): ListResult<GitBranchCommitModel> {

        var gitData = mor.dev.gitData.queryById(gitId).toEntity()
            .must()
            .elseThrow { "找不到git数据" }


        var gitItems = gitData.path
            .replace(".git", "", false)
            .trim('/')
            .split("/")

        if (gitItems.size < 2) {
            throw RuntimeException("gitData.path,非法，${gitData.path}")
        }


        val gitServer = mor.dev.gitServer.queryById(gitData.server.id).toEntity();
        if (gitServer == null) {
            return ListResult.error("找不到git服务器")
        }

        var owner = gitItems[0]
        var repo = gitItems[1]

        return GitApiService.getInstance(gitServer.gitServerType)
            .getBranches(
                gitServer.host,
                gitData.accessToken.AsString(gitServer.accessToken),
                owner,
                repo,
                take
            )
    }

//    @PostMapping("/delete-file")
//    fun deleteFile(
//        gitServerId: String,
//        gitServerCode: String,
//        owner: String,
//        repo: String,
//        branch: String,
//        fileName: String,
//        committerName: String,
//        message: String
//    ): JsonResult {
//        val gitServer = mor.dev.gitServer.query()
//            .apply {
//                if (gitServerId.HasValue) {
//                    this.where { it.id mongoEquals gitServerId }
//                }
//
//                if (gitServerCode.HasValue) {
//                    this.where { it.code mongoEquals gitServerCode }
//                }
//            }.toEntity();
//        if (gitServer == null) {
//            return JsonResult.error("找不到git服务器")
//        }
//
//        return gitEaService.deleteFile(gitServer, owner, repo, branch, fileName, committerName, message)
//    }


//    @PostMapping("/list-files")
//    fun listFiles(
//        gitServerId: String,
//        gitServerCode: String,
//        owner: String,
//        repo: String,
//        branch: String,
//        filePath: String,
//    ): ListResult<String> {
//        val gitServer = mor.dev.gitServer.query()
//            .apply {
//                if (gitServerId.HasValue) {
//                    this.where { it.id mongoEquals gitServerId }
//                }
//
//                if (gitServerCode.HasValue) {
//                    this.where { it.code mongoEquals gitServerCode }
//                }
//            }.toEntity();
//        if (gitServer == null) {
//            return ListResult.error("找不到git服务器")
//        }
//
//        gitEaService.listFiles(gitServer, owner, repo, branch, filePath).apply {
//            if (this.msg.HasValue) {
//                return ListResult.error(this.msg);
//            }
//            return ListResult.of(this.data.map { it.fileName })
//        }
//    }
}
